<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>P-Code Operation Reference</title>
<link rel="stylesheet" type="text/css" href="DefaultStyle.css">
<link rel="stylesheet" type="text/css" href="languages.css">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
<link rel="home" href="pcoderef.html" title="P-Code Reference Manual">
<link rel="up" href="pcoderef.html" title="P-Code Reference Manual">
<link rel="prev" href="pcoderef.html" title="P-Code Reference Manual">
<link rel="next" href="pseudo-ops.html" title="Pseudo P-CODE Operations">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="navheader">
<table width="100%" summary="Navigation header">
<tr><th colspan="3" align="center">P-Code Operation Reference</th></tr>
<tr>
<td width="20%" align="left">
<a accesskey="p" href="pcoderef.html">Prev</a> </td>
<th width="60%" align="center"> </th>
<td width="20%" align="right"> <a accesskey="n" href="pseudo-ops.html">Next</a>
</td>
</tr>
</table>
<hr>
</div>
<div class="sect1">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="pcodedescription"></a>P-Code Operation Reference</h2></div></div></div>
<p>
For each possible p-code operation, we give a brief description and
provide a table that lists the inputs that must be present and their
meaning. We also list the basic syntax for denoting the operation when
describing semantics in a processor specification file.
</p>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_copy"></a>COPY</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="copy.htmltable"></a><table xml:id="copy.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Source varnode.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Destination varnode.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
Copy a sequence of contiguous bytes from anywhere to anywhere. Size of
input0 and output must be the same.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_load"></a>LOAD</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="load.htmltable"></a><table xml:id="load.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td>(<span class="bold"><strong>special</strong></span>)</td>
  <td>Constant ID of space to load from.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode containing pointer offset to data.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Destination varnode.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = *input1;</code></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = *[input0]input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This instruction loads data from a dynamic location into the output
variable by dereferencing a pointer. The “pointer” comes in two
pieces. One piece, input1, is a normal variable containing the offset
of the object being pointed at. The other piece, input0, is a constant
indicating the space into which the offset applies. The data in input1
is interpreted as an unsigned offset and should have the same size as
the space referred to by the ID, i.e. a 4-byte address space requires
a 4-byte offset. The space ID is not manually entered by a user but is
automatically generated by the p-code compiler. The amount of data
loaded by this instruction is determined by the size of the output
variable.  It is easy to confuse the address space of the output and
input1 variables and the Address Space represented by the ID, which
could all be different. Unlike many programming models, there are
multiple spaces that a “pointer” can refer to, and so an extra ID is
required.
</p>
<p>
It is possible for the addressable unit of an address
space to be bigger than a single byte. If
the <span class="bold"><strong>wordsize</strong></span> attribute of the space
given by the ID is bigger than one, the offset into the space obtained
from input1 must be multiplied by this value in order to obtain the
correct byte offset into the space.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_store"></a>STORE</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="store.htmltable"></a><table xml:id="store.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td>(<span class="bold"><strong>special</strong></span>)</td>
  <td>Constant ID of space to store into.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode containing pointer offset of destination.</td>
</tr>
<tr>
  <td align="right">input2</td>
  <td></td>
  <td>Varnode containing data to be stored.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">*input1 = input2;</code></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">*[input0]input1 = input2; </code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This instruction is the complement
of <span class="bold"><strong>LOAD</strong></span>.  The data in the variable
input2 is stored at a dynamic location by dereferencing a pointer. As
with <span class="bold"><strong>LOAD</strong></span>, the “pointer” comes in two
pieces: a space ID part, and an offset variable. The size of input1
must match the address space specified by the ID, and the amount of
data stored is determined by the size of input2.
</p>
<p>
Its possible for the addressable unit of an address
space to be bigger than a single byte. If
the <span class="bold"><strong>wordsize</strong></span> attribute of the space
given by the ID is bigger than one, the offset into the space obtained
from input1 must be multiplied by this value in order to obtain the
correct byte offset into the space.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_branch"></a>BRANCH</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="branch.htmltable"></a><table xml:id="branch.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody><tr>
  <td align="right">input0</td>
  <td>(<span class="bold"><strong>special</strong></span>)</td>
  <td>Location of next instruction to execute.</td>
</tr></tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">goto input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an absolute jump instruction. The varnode parameter input0 encodes
the destination address (address space and offset) of the jump. The varnode is not
treated as a variable for this instruction and does not store the destination. Its address space and
offset <span class="emphasis"><em>are</em></span> the destination. The size of input0 is irrelevant.
</p>
<p>
Confusion about the meaning of this instruction can result because of
the translation from machine instructions to p-code. The destination of the jump is
a <span class="emphasis"><em>machine</em></span> address and refers to
the <span class="emphasis"><em>machine</em></span> instruction at that address. When
attempting to determine which p-code instruction is executed next, the
rule is: execute the first p-code instruction resulting from the
translation of the machine instruction(s) at that address. The
resulting p-code instruction may not be attached directly to the
indicated address due to NOP instructions and delay slots.
</p>
<p>
If input0 is constant, i.e. its address space
is the <span class="bold"><strong>constant</strong></span>
address space, then it encodes a <span class="emphasis"><em>p-code relative branch</em></span>.
In this case, the offset of input0 is considered a relative offset into
the indexed list of p-code operations corresponding to the translation
of the current machine instruction. This allows branching within the
operations forming a single instruction. For example, if
the <span class="bold"><strong>BRANCH</strong></span> occurs as the pcode
operation with index 5 for the instruction, it can branch to operation
with index 8 by specifying a constant destination “address” of
3. Negative constants can be used for backward branches.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_cbranch"></a>CBRANCH</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="cbranch.htmltable"></a><table xml:id="cbranch.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td>(<span class="bold"><strong>special</strong></span>)</td>
  <td>Location of next instruction to execute.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Boolean varnode indicating whether branch is taken.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">if (input1) goto input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a conditional branch instruction where the dynamic condition
for taking the branch is determined by the 1 byte variable input1. If
this variable is non-zero, the condition is
considered <span class="emphasis"><em>true</em></span> and the branch is taken.  As in
the <span class="bold"><strong>BRANCH</strong></span> instruction the parameter
input0 is not treated as a variable but as an address and is
interpreted in the same way. Furthermore, a constant space address is
also interpreted as a relative address so that
a <span class="bold"><strong>CBRANCH</strong></span> can do <span class="emphasis"><em>p-code
relative branching</em></span>.  See the discussion for the
<span class="bold"><strong>BRANCH</strong></span> operation.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_branchind"></a>BRANCHIND</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="branchind.htmltable"></a><table xml:id="branchind.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody><tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode containing offset of next instruction.</td>
</tr></tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">goto [input0];</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an indirect branching instruction. The address to branch to is
determined dynamically (at runtime) by examining the contents of the
variable input0. As this instruction is currently defined, the
variable input0 only contains the <span class="emphasis"><em>offset</em></span> of the
destination, and the address space is taken from the address
associated with the branching instruction
itself. So <span class="emphasis"><em>execution can only branch within the same address
space</em></span> via this instruction. The size of the variable input0
must match the size of offsets for the current address space. P-code
relative branching is not possible with <span class="bold"><strong>BRANCHIND</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_call"></a>CALL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="call.htmltable"></a><table xml:id="call.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td>(<span class="bold"><strong>special</strong></span>)</td>
  <td>Location of next instruction to execute.</td>
</tr>
<tr>
  <td align="right">[input1]</td>
  <td></td>
  <td>First parameter to call (never present in raw p-code)</td>
</tr>
<tr>
  <td align="right">...</td>
  <td></td>
  <td>Additional parameters to call (never present in raw p-code)</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">call [input0];</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This instruction is semantically equivalent to
the <span class="bold"><strong>BRANCH</strong></span> instruction.
<span class="bold"><strong>Beware:</strong></span> This instruction does not
behave like a typical function call. In particular, there is no
internal stack in p-code for saving the return address. Use of this
instruction instead of <span class="bold"><strong>BRANCH</strong></span> is
intended to provide a hint to algorithms that try to follow code flow.
It indicates that the original machine instruction, of which this
p-code instruction is only a part, is intended to be a function
call. The p-code instruction does not implement the full semantics of
the call itself; it only implements the final branch.
</p>
<p>
In the raw p-code translation process, this operation can only take
input0, but in follow-on analysis, it can take arbitrary additional inputs.
These represent (possibly partial) recovery of the parameters being
passed to the logical <span class="emphasis"><em>call</em></span> represented by this
operation.  These additional parameters have no effect on the original
semantics of the raw p-code but naturally hold the varnode values flowing
into the call.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_callind"></a>CALLIND</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="callind.htmltable"></a><table xml:id="callind.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode containing offset of next instruction.</td>
</tr>
<tr>
  <td align="right">[input1]</td>
  <td></td>
  <td>First parameter to call (never present in raw p-code)</td>
</tr>
<tr>
  <td align="right">...</td>
  <td></td>
  <td>Additional parameters to call (never present in raw p-code)</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">call [input0];</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This instruction is semantically equivalent to
the <span class="bold"><strong>BRANCHIND</strong></span> instruction. It does
not perform a function call in the usual sense of the term. It merely
indicates that the original machine instruction is intended to be an
indirect call. See the discussion for
the <span class="bold"><strong>CALL</strong></span> instruction.
</p>
<p>As with the <span class="bold"><strong>CALL</strong></span> instruction,
this operation may take additional inputs when not in raw form, representing
the parameters being passed to the logical call.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_return"></a>RETURN</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="return.htmltable"></a><table xml:id="return.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode containing offset of next instruction.</td>
</tr>
<tr>
  <td align="right">[input1]</td>
  <td></td>
  <td>Value returned from call (never present in raw p-code)</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">return [input0];</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This instruction is semantically equivalent to
the <span class="bold"><strong>BRANCHIND</strong></span> instruction. It does
not perform a return from subroutine in the usual sense of the
term. It merely indicates that the original machine instruction is
intended to be a return from subroutine. See the discussion for
the <span class="bold"><strong>CALL</strong></span> instruction.
</p>
<p>
Similarly to <span class="bold"><strong>CALL</strong></span> and <span class="bold"><strong>CALLIND</strong></span>,
this operation may take an additional input when not in raw form. If input1 is
present it represents the value being <span class="emphasis"><em>returned</em></span> by this operation.
This is used by analysis algorithms to hold the value logically flowing back to the parent
subroutine.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_piece"></a>PIECE</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="piece.htmltable"></a><table xml:id="piece.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode containing most significant data to merge.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode containing least significant data to merge.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode to contain resulting concatenation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><span class="emphasis"><em>Cannot (currently) be explicitly coded</em></span></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a concatenation operator that understands the endianness of the
data. The size of input0 and input1 must add up to the size of
output. The data from the inputs is concatenated in such a way that,
if the inputs and output are considered integers, the first input
makes up the most significant part of the output.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_subpiece"></a>SUBPIECE</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="subpiece.htmltable"></a><table xml:id="subpiece.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode containing source data to truncate.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td>(<span class="bold"><strong>constant</strong></span>)</td>
  <td>Constant indicating how many bytes to truncate.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode to contain result of truncation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0(input1);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a truncation operator that understands the endianness of the
data. Input1 indicates the number of least significant bytes of input0
to be thrown away. Output is then filled with any remaining bytes of
input0 <span class="emphasis"><em>up to the size of output</em></span>. If the size of
output is smaller than the size of input0 minus the constant input1,
then the additional most significant bytes of input0 will also be
truncated.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_popcount"></a>POPCOUNT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="popcount.htmltable"></a><table xml:id="popcount.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Input varnode to count.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Resulting integer varnode containing count.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = popcount(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a bit count (population count) operator. Within the binary representation of the value
contained in the input varnode, the number of 1 bits are counted and then returned in the
output varnode. A value of 0 returns 0, a 4-byte varnode containing the value 2<sup>32</sup>-1
(all bits set) returns 32, for instance. The input and output varnodes can have any size. The resulting
count is zero extended into the output varnode.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_lzcount"></a>LZCOUNT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="lzcount.htmltable"></a><table xml:id="lzcount.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Input varnode to count.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Resulting integer varnode containing count.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = lzcount(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operator counts the number of zeros starting at the most significant bit.
For instance, for a 4-byte varnode, a value of 0 returns 32, a value of 1
returns 31, and the value 2<sup>31</sup> returns 0.
The resulting count is zero extended into the output varnode.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_equal"></a>INT_EQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intequal.htmltable"></a><table xml:id="intequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 == input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is the integer equality operator. Output is
assigned <span class="emphasis"><em>true</em></span>, if input0 equals input1. It works
for signed, unsigned, or any contiguous data where the match must be
down to the bit. Both inputs must be the same size, and the output
must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_notequal"></a>INT_NOTEQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intnotequal.htmltable"></a><table xml:id="intnotequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 != input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is the integer inequality operator. Output is
assigned <span class="emphasis"><em>true</em></span>, if input0 does not equal
input1. It works for signed, unsigned, or any contiguous data where
the match must be down to the bit. Both inputs must be the same size,
and the output must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_less"></a>INT_LESS</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intless.htmltable"></a><table xml:id="intless.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First unsigned varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second unsigned varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &lt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an unsigned integer comparison operator. If the unsigned
integer input0 is strictly less than the unsigned integer input1,
output is set to <span class="emphasis"><em>true</em></span>. Both inputs must be the
same size, and the output must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sless"></a>INT_SLESS</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsless.htmltable"></a><table xml:id="intsless.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First signed varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second signed varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 s&lt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a signed integer comparison operator. If the signed integer
input0 is strictly less than the signed integer input1, output is set
to <span class="emphasis"><em>true</em></span>. Both inputs must be the same size, and
the output must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_lessequal"></a>INT_LESSEQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intlessequal.htmltable"></a><table xml:id="intlessequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First unsigned varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second unsigned varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &lt;= input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an unsigned integer comparison operator. If the unsigned
integer input0 is less than or equal to the unsigned integer input1,
output is set to <span class="emphasis"><em>true</em></span>. Both inputs must be the
same size, and the output must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_slessequal"></a>INT_SLESSEQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intslessequal.htmltable"></a><table xml:id="intslessequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First signed varnode to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second signed varnode to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 s&lt;= input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a signed integer comparison operator. If the signed integer
input0 is less than or equal to the signed integer input1, output is
set to <span class="emphasis"><em>true</em></span>. Both inputs must be the same size,
and the output must have a size of 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_zext"></a>INT_ZEXT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intzext.htmltable"></a><table xml:id="intzext.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode to zero-extend.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing zero-extended result.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = zext(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
Zero-extend the data in input0 and store the result in output. Copy
all the data from input0 into the least significant positions of
output. Fill out any remaining space in the most significant bytes of
output with zero. The size of output must be strictly bigger than the
size of input.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sext"></a>INT_SEXT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsext.htmltable"></a><table xml:id="intsext.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode to sign-extend.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing sign-extended result.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = sext(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
Sign-extend the data in input0 and store the result in output. Copy
all the data from input0 into the least significant positions of
output. Fill out any remaining space in the most significant bytes of
output with either zero or all ones (0xff) depending on the most
significant bit of input0. The size of output must be strictly bigger
than the size of input0.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_add"></a>INT_ADD</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intadd.htmltable"></a><table xml:id="intadd.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to add.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to add.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of integer addition.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 + input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is standard integer addition. It works for either unsigned or
signed interpretations of the integer encoding (twos complement). Size
of both inputs and output must be the same. The addition is of course
performed modulo this size. Overflow and carry conditions are
calculated by other
operations. See <span class="bold"><strong>INT_CARRY</strong></span>
and <span class="bold"><strong>INT_SCARRY</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sub"></a>INT_SUB</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsub.htmltable"></a><table xml:id="intsub.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode to subtract from first.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of integer subtraction.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 - input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is standard integer subtraction. It works for either unsigned or
signed interpretations of the integer encoding (twos complement). Size
of both inputs and output must be the same. The subtraction is of
course performed modulo this size. Overflow and borrow conditions are
calculated by other
operations. See <span class="bold"><strong>INT_SBORROW</strong></span>
and <span class="bold"><strong>INT_LESS</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_carry"></a>INT_CARRY</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intcarry.htmltable"></a><table xml:id="intcarry.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to add.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to add.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean result containing carry condition.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = carry(input0,input1);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation checks for unsigned addition overflow or carry
conditions. If the result of adding input0 and input1 as unsigned
integers overflows the size of the varnodes, output is
assigned <span class="emphasis"><em>true</em></span>. Both inputs must be the same size,
and output must be size 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_scarry"></a>INT_SCARRY</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intscarry.htmltable"></a><table xml:id="intscarry.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to add.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to add.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean result containing signed overflow condition.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = scarry(input0,input1);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation checks for signed addition overflow or carry
conditions. If the result of adding input0 and input1 as signed
integers overflows the size of the varnodes, output is
assigned <span class="emphasis"><em>true</em></span>. Both inputs must be the same size,
and output must be size 1.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sborrow"></a>INT_SBORROW</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsborrow.htmltable"></a><table xml:id="intsborrow.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode to subtract from first.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean result containing signed overflow condition.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = sborrow(input0,input1);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation checks for signed subtraction overflow or borrow
conditions. If the result of subtracting input1 from input0 as signed
integers overflows the size of the varnodes, output is
assigned <span class="emphasis"><em>true</em></span>. Both inputs must be the same size,
and output must be size 1.  Note that the equivalent unsigned
subtraction overflow condition
is <span class="bold"><strong>INT_LESS</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_2comp"></a>INT_2COMP</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="int2comp.htmltable"></a><table xml:id="int2comp.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First to negate.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing twos complement.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = -input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is the twos complement or arithmetic negation operation. Treating input0 as a signed
integer, the result is the same integer value but with the opposite sign. This is equivalent
to doing a bitwise negation of input0 and then adding one. Both input0 and output must
be the same size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_negate"></a>INT_NEGATE</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intnegate.htmltable"></a><table xml:id="intnegate.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode to negate.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing bitwise negation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = ~input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is the bitwise negation operation. Output is the result of taking
every bit of input0 and flipping it. Both input0 and output must be
the same size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_xor"></a>INT_XOR</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intxor.htmltable"></a><table xml:id="intxor.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First input to exclusive-or.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second input to exclusive-or.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing exclusive-or of inputs.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 ^ input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs a logical Exclusive-Or on the bits of input0
and input1. Both inputs and output must be the same size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_and"></a>INT_AND</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intand.htmltable"></a><table xml:id="intand.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First input to logical-and.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second input to logical-and.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing logical-and of inputs.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &amp; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs a Logical-And on the bits of input0 and input1. Both inputs and
output must be the same size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_or"></a>INT_OR</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intor.htmltable"></a><table xml:id="intor.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First input to logical-or.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second input to logical-or.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing logical-or of inputs.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 | input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs a Logical-Or on the bits of input0 and input1. Both inputs and
output must be the same size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_left"></a>INT_LEFT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intleft.htmltable"></a><table xml:id="intleft.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode input being shifted.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode indicating number of bits to shift.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing shifted result.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &lt;&lt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs a left shift on input0. The value given by
input1, interpreted as an unsigned integer, indicates the number of
bits to shift. The vacated (least significant) bits are filled with
zero. If input1 is zero, no shift is performed and input0 is copied
into output. If input1 is larger than the number of bits in output,
the result is zero. Both input0 and output must be the same
size. Input1 can be any size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_right"></a>INT_RIGHT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intright.htmltable"></a><table xml:id="intright.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode input being shifted.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode indicating number of bits to shift.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing shifted result.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &gt;&gt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs an unsigned (logical) right shift on
input0. The value given by input1, interpreted as an unsigned integer,
indicates the number of bits to shift. The vacated (most significant)
bits are filled with zero. If input1 is zero, no shift is performed
and input0 is copied into output. If input1 is larger than the number
of bits in output, the result is zero. Both input0 and output must be
the same size. Input1 can be any size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sright"></a>INT_SRIGHT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsright.htmltable"></a><table xml:id="intsright.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Varnode input being shifted.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Varnode indicating number of bits to shift.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing shifted result.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 s&gt;&gt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation performs a signed (arithmetic) right shift on
input0. The value given by input1, interpreted as an unsigned integer,
indicates the number of bits to shift. The vacated bits are filled
with the original value of the most significant (sign) bit of input0.
If input1 is zero, no shift is performed and input0 is copied into
output. If input1 is larger than the number of bits in output, the
result is zero or all 1-bits (-1), depending on the original sign of
input0. Both input0 and output must be the same size. Input1 can be
any size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_mult"></a>INT_MULT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intmult.htmltable"></a><table xml:id="intmult.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode to be multiplied.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode to be multiplied.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of multiplication.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 * input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an integer multiplication operation. The result of multiplying
input0 and input1, viewed as integers, is stored in output. Both
inputs and output must be the same size. The multiplication is
performed modulo the size, and the result is true for either a signed
or unsigned interpretation of the inputs and output. To get extended
precision results, the inputs must first by zero-extended or
sign-extended to the desired size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_div"></a>INT_DIV</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intdiv.htmltable"></a><table xml:id="intdiv.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode input (divisor).</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of division.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 / input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an unsigned integer division operation. Divide input0 by
input1, truncating the result to the nearest integer, and store the
result in output. Both inputs and output must be the same size. There
is no handling of division by zero. To simulate a processor’s handling
of a division-by-zero trap, other operations must be used before
the <span class="bold"><strong>INT_DIV</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_rem"></a>INT_REM</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intrem.htmltable"></a><table xml:id="intrem.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode input (divisor).</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing remainder of division.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 % input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an unsigned integer remainder operation. The remainder of
performing the unsigned integer division of input0 and input1 is put
in output. Both inputs and output must be the same size. If q =
input0/input1, using the <span class="bold"><strong>INT_DIV</strong></span>
operation defined above, then output satisfies the equation q*input1 +
output = input0, using the <span class="bold"><strong>INT_MULT</strong></span>
and <span class="bold"><strong>INT_ADD</strong></span> operations.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_sdiv"></a>INT_SDIV</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsdiv.htmltable"></a><table xml:id="intsdiv.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode input (divisor).</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of signed division.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 s/ input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a signed integer division operation. The resulting integer is
the one closest to the rational value input0/input1 but which is still
smaller in absolute value. Both inputs and output must be the same
size. There is no handling of division by zero. To simulate a
processor’s handling of a division-by-zero trap, other operations must
be used before the <span class="bold"><strong>INT_SDIV</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int_srem"></a>INT_SREM</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="intsrem.htmltable"></a><table xml:id="intsrem.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First varnode input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second varnode input (divisor).</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing remainder of signed division.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 s% input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a signed integer remainder operation. The remainder of
performing the signed integer division of input0 and input1 is put in
output. Both inputs and output must be the same size. If q = input0 s/
input1, using the <span class="bold"><strong>INT_SDIV</strong></span> operation
defined above, then output satisfies the equation q*input1 + output =
input0, using the <span class="bold"><strong>INT_MULT</strong></span>
and <span class="bold"><strong>INT_ADD</strong></span> operations.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_bool_negate"></a>BOOL_NEGATE</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="boolnegate.htmltable"></a><table xml:id="boolnegate.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Boolean varnode to negate.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of negation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = !input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a logical negate operator, where we assume input0 and output
are boolean values.  It puts the logical complement of input0, treated
as a single bit, into output. Both input0 and output are size
1. Boolean values are implemented with a full byte, but are still
considered to only support a value of <span class="emphasis"><em>true</em></span>
or <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_bool_xor"></a>BOOL_XOR</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="boolxor.htmltable"></a><table xml:id="boolxor.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First boolean input to exclusive-or.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second boolean input to exclusive-or.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of exclusive-or.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 ^^ input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an Exclusive-Or operator, where we assume the inputs and
output are boolean values. It puts the exclusive-or of input0 and
input1, treated as single bits, into output.  Both inputs and output
are size 1. Boolean values are implemented with a full byte, but are
still considered to only support a value of <span class="emphasis"><em>true</em></span>
or <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_bool_and"></a>BOOL_AND</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="booland.htmltable"></a><table xml:id="booland.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First boolean input to logical-and.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second boolean input to logical-and.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of logical-and.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 &amp;&amp; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a Logical-And operator, where we assume the inputs and output
are boolean values. It puts the logical-and of input0 and input1,
treated as single bits, into output.  Both inputs and output are size
1. Boolean values are implemented with a full byte, but are still
considered to only support a value of <span class="emphasis"><em>true</em></span>
or <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_bool_or"></a>BOOL_OR</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="boolor.htmltable"></a><table xml:id="boolor.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First boolean input to logical-or.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second boolean input to logical-or.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of logical-or.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 || input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a Logical-Or operator, where we assume the inputs and output
are boolean values. It puts the logical-or of input0 and input1,
treated as single bits, into output.  Both inputs and output are size
1. Boolean values are implemented with a full byte, but are still
considered to only support a value of <span class="emphasis"><em>true</em></span>
or <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_equal"></a>FLOAT_EQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatequal.htmltable"></a><table xml:id="floatequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f== input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point equality operator. Output is
assigned <span class="emphasis"><em>true</em></span>, if input0 and input1 are
considered equal as floating-point values. Both inputs must be the
same size, and output is size 1. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_notequal"></a>FLOAT_NOTEQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatnotequal.htmltable"></a><table xml:id="floatnotequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f!= input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point inequality operator. Output is
assigned <span class="emphasis"><em>true</em></span>, if input0 and input1 are not
considered equal as floating-point values. Both inputs must be the
same size, and output is size 1. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_less"></a>FLOAT_LESS</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatless.htmltable"></a><table xml:id="floatless.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f&lt; input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a comparison operator, where both inputs are considered
floating-point values. Output is assigned <span class="emphasis"><em>true</em></span>,
if input0 is less than input1. Both inputs must be the same size, and
output is size 1. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_lessequal"></a>FLOAT_LESSEQUAL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatlessequal.htmltable"></a><table xml:id="floatlessequal.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to compare.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of comparison.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f&lt;= input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a comparison operator, where both inputs are considered
floating-point values. Output is assigned <span class="emphasis"><em>true</em></span>,
if input0 is less than or equal to input1. Both inputs must be the
same size, and output is size 1. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="emphasis"><em>false</em></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_add"></a>FLOAT_ADD</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatadd.htmltable"></a><table xml:id="floatadd.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to add.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to add.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of addition.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f+ input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point addition operator. The result of adding
input0 and input1 as floating-point values is stored in output. Both
inputs and output must be the same size. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>. If any overflow condition
occurs, output is set to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_sub"></a>FLOAT_SUB</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatsub.htmltable"></a><table xml:id="floatsub.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Floating-point varnode to subtract from first.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of subtraction.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f- input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point subtraction operator. The result of
subtracting input1 from input0 as floating-point values is stored in
output. Both inputs and output must be the same size.  If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>. If any overflow condition
occurs, output is set to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_mult"></a>FLOAT_MULT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatmult.htmltable"></a><table xml:id="floatmult.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input to multiply.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input to multiply.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of multiplication.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f* input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point multiplication operator. The result of
multiplying input0 to input1 as floating-point values is stored in
output. Both inputs and output must be the same size.  If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>. If any overflow condition
occurs, output is set to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_div"></a>FLOAT_DIV</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatdiv.htmltable"></a><table xml:id="floatdiv.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>First floating-point input.</td>
</tr>
<tr>
  <td align="right">input1</td>
  <td></td>
  <td>Second floating-point input (divisor).</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of division.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = input0 f/ input1;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point division operator. The result of dividing
input1 into input0 as floating-point values is stored in output. Both
inputs and output must be the same size. If either input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>. If any overflow condition
occurs, output is set to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_neg"></a>FLOAT_NEG</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatneg.htmltable"></a><table xml:id="floatneg.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point varnode to negate.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode containing result of negation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = f- input0;</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point negation operator. The floating-point value
in input0 is stored in output with the opposite sign. Both input and
output must be the same size. If input
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_abs"></a>FLOAT_ABS</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatabs.htmltable"></a><table xml:id="floatabs.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing absolute-value.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = abs(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point absolute-value operator. The absolute value
of input0 is stored in output. Both input0 and output must be the same
size. If input0 is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_sqrt"></a>FLOAT_SQRT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatsqrt.htmltable"></a><table xml:id="floatsqrt.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing square root.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = sqrt(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point square-root operator. The square root of
input0 is stored in output.  Both input0 and output must be the same
size. If input0 is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_ceil"></a>FLOAT_CEIL</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatceil.htmltable"></a><table xml:id="floatceil.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing result of truncation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = ceil(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation rounds input0, as a signed floating-point value, towards <span class="emphasis"><em>positive infinity</em></span>.
For instance, the value 1.2 rounds to 2.0; -1.2 rounds to -1.0.
The integral value obtained by rounding input0 up is stored in output, as a floating-point
value. Both input0 and output must be the same size. If input0
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_floor"></a>FLOAT_FLOOR</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatfloor.htmltable"></a><table xml:id="floatfloor.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing result of truncation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = floor(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operation rounds input0, as a floating-point value, towards <span class="emphasis"><em>negative infinity</em></span>.
For instance, the value 1.2 rounds to 1.0 and -1.2 rounds to -2.0.
The integral value obtained by rounding input0 down is stored in output, as a floating-point
value. <span class="bold"><strong>FLOAT_FLOOR</strong></span> does <span class="emphasis"><em>not</em></span> produce
a twos complement integer output (See the <span class="bold"><strong>TRUNC</strong></span> operator).
Both input0 and output must be the same size. If input0
is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_round"></a>FLOAT_ROUND</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatround.htmltable"></a><table xml:id="floatround.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Varnode result containing result of truncation.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = round(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point rounding operator. The integral value closest to the
floating-point value in input0 is stored in output, as a floating-point value.
For example, 1.2 rounds to 1.0 and 1.9 rounds to 2.0.
<span class="bold"><strong>FLOAT_ROUND</strong></span> does <span class="emphasis"><em>not</em></span>
produce a twos complement integer output (See the <span class="bold"><strong>TRUNC</strong></span> operator).
Both input0 and output must be the same size. If
input0 is <span class="bold"><strong>NaN</strong></span>, output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float_nan"></a>FLOAT_NAN</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="floatnan.htmltable"></a><table xml:id="floatnan.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Boolean varnode containing result of NaN test.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = nan(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This operator returns <span class="emphasis"><em>true</em></span> in output if input0 is
interpreted as <span class="bold"><strong>NaN</strong></span>. Output must be
size 1, and input0 can be any size.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_int2float"></a>INT2FLOAT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="int2float.htmltable"></a><table xml:id="int2float.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Signed integer input.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Result containing floating-point conversion.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = int2float(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is an integer to floating-point conversion operator. Input0
viewed as a signed integer is converted to floating-point format and
stored in output. Input0 and output do not need to be the same
size. The conversion to floating-point may involve a loss of
precision.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_float2float"></a>FLOAT2FLOAT</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="float2float.htmltable"></a><table xml:id="float2float.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input varnode.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Result varnode containing conversion.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = float2float(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point precision conversion operator. The
floating-point value in input0 is converted to a floating-point value
of a different size and stored in output. If output is smaller than
input0, then the operation will lose precision. Input0 and output
should be different sizes. If input0
is <span class="bold"><strong>NaN</strong></span>, then output is set
to <span class="bold"><strong>NaN</strong></span>.
</p>
</div>
<div class="sect2">
<div class="titlepage"><div><div><h3 class="title">
<a name="cpui_trunc"></a>TRUNC</h3></div></div></div>
<div class="informalexample"><div class="table">
<a name="trunc.htmltable"></a><table xml:id="trunc.htmltable" frame="above" width="80%" rules="groups">
<col width="23%">
<col width="15%">
<col width="61%">
<thead><tr>
  <td align="center" colspan="2"><span class="bold"><strong>Parameters</strong></span></td>
  <td><span class="bold"><strong>Description</strong></span></td>
</tr></thead>
<tbody>
<tr>
  <td align="right">input0</td>
  <td></td>
  <td>Floating-point input varnode.</td>
</tr>
<tr>
  <td align="right">output</td>
  <td></td>
  <td>Resulting integer varnode containing conversion.</td>
</tr>
</tbody>
<tfoot>
<tr>
  <td align="center" colspan="2"><span class="bold"><strong>Semantic statement</strong></span></td>
  <td></td>
</tr>
<tr>
  <td></td>
  <td colspan="2"><code class="code">output = trunc(input0);</code></td>
</tr>
</tfoot>
</table>
</div></div>
<p>
This is a floating-point to integer conversion operator. The
floating-point value in input0 is converted to a signed integer and
stored in output using the default twos complement encoding.
The fractional part of input0 is dropped in the conversion by rounding <span class="emphasis"><em>towards zero</em></span>.
Input0 and output can be different sizes. 
</p>
</div>
</div>
<div class="navfooter">
<hr>
<table width="100%" summary="Navigation footer">
<tr>
<td width="40%" align="left">
<a accesskey="p" href="pcoderef.html">Prev</a> </td>
<td width="20%" align="center"> </td>
<td width="40%" align="right"> <a accesskey="n" href="pseudo-ops.html">Next</a>
</td>
</tr>
<tr>
<td width="40%" align="left" valign="top">P-Code Reference Manual </td>
<td width="20%" align="center"><a accesskey="h" href="pcoderef.html">Home</a></td>
<td width="40%" align="right" valign="top"> Pseudo P-CODE Operations</td>
</tr>
</table>
</div>
</body>
</html>
